UART Custom Adapters

    Structure {

        usercode1 '''
            #include "uart/Uart.h"      // contains standard UART definitions
        '''
        usercode3 '''

            // Initialize 6 receive buffers, each 255 byte long.
            // Initialize 1 txBuffer that is 50 byte long.

            static uint8_t __attribute__((section(".dmaMemSection_D2"))) rxBuffers[6][255];
            static uint8_t __attribute__((section(".dmaMemSection_D2"))) txBuffer[50];

            static int16_t chunkHandler(uint8_t* buffer, uint8_t newDataLength) {
            // This function is called when a timeout
			// in data reception occurs or when the receive buffer is full.
                return 0;
            }
        '''

        ...

    }

	ActorClass AIntermediateActor {
		Interface {
			Port uartInterface: PMyCustomProtocol
			conjugated Port uartCom: PCustomUartCommunication
			conjugated Port uartControl: PCustomUartControl
		}

		Structure {

			usercode1 '''
				#include "uart/Uart.h"
			'''
			usercode3 '''

				// Initialize 6 receive buffers, each 255 byte long.
				// Initialize 1 txBuffer that is 50 byte long.
				// Note that the buffers have to be in the DMA memory section.
				static uint8_t __attribute__((section(".dmaMemSection_D2"))) rxBuffers[6][255];
				static uint8_t __attribute__((section(".dmaMemSection_D2"))) txBuffer[50];

				static uint8_t dataBuffer[100];

				static int16_t chunkHandler(uint8_t* buffer, uint8_t newDataLength) {
					for (uint8_t i = 0; i < newDataLength; i++) {
						if (buffer[i] == '\n') {
							return i - newDataLength;
						}
					}
					return 20; // read the next 20 bytes
				}
			'''

			external Port uartCom
			external Port uartControl
			external Port uartInterface
			SAP logger: PLogger
			SAP timer: PTimer
		}
		Behavior {
			StateMachine {
				State running
				Transition init0: initial -> delay {
					action '''timer.startTimeout(500);'''
				}
				Transition tr0: running -> running {
					triggers {
						<sendData: uartInterface>
					}
					action '''

						for(int i=0; i<transitionData->dataLength; i++) {
							txBuffer[i] = transitionData->bufferPtr[i];
						}

						DCustomUartNotification pkt = {
							.bufferPtr = txBuffer,
							.dataLength = transitionData->dataLength,
						};

						uartCom.sendPacket(&pkt);
					'''
				}
				Transition tr1: running -> running {
					triggers {
						<receivedPacket: uartCom>
					}
					action '''

						uint8_t ctr=0;

						// init the data structure that will be sent later
						DCustomUartNotification pkt = {
							.bufferPtr = 0,
							.dataLength = 0,
						};
						ctr=0;
						// This place in code is for additional or
						// computationally expensive message parsing.

						// extract single messages from the buffer
						while(ctr<transitionData->dataLength){
							pkt.bufferPtr = (dataBuffer+ctr);
							while(ctr<transitionData->dataLength){
								// check if the current character is the delimiter
								if(transitionData->bufferPtr[ctr] != '#') {
									dataBuffer[ctr]=transitionData->bufferPtr[ctr];
									ctr++;
								}
								else {
									pkt.dataLength = ctr;
									ctr++;
									break;
								}
							}
							uartInterface.receivedData(&pkt);
						}
						uartCom.freeRxBuffer(transitionData->bufferPtr);		// free the buffer
					'''
				}
				Transition tr7: running -> running {
					triggers {
						<bufferOverflow: uartControl>
					}
					action '''logger.log("UART: Buffer overflow!");'''
				}
				State configuration
				State delay
				Transition tr3: configuration -> running {
					triggers {
						<configurationComplete: uartControl>
					}
					action '''uartControl.enableReceiveData();
							  uartInterface.uartReady();'''
				}
				Transition tr4: delay -> configuration {
					triggers {
						<timeout: timer>
					}
					action '''
						DCustomUartConfiguration cfg = {
						        .uartConfig = {
						            .uartBaudrate = 115200,
						            .uartParity = EParity_NONE,
						            .uartStopbits = EStopBits_STOPBITS_1,
						            .uartDatabits = EUartDataBits_DATA_BITS_8,
						        },
						        .rxBufferPtrs = {rxBuffers[0], rxBuffers[1], rxBuffers[2], rxBuffers[3], rxBuffers[4], rxBuffers[5]},
						        .noOfRxBuffers = 6,
						        .rxBufferLength = 255,
						        .initialChunkSize = 255,
						        .nextChunkHandler = chunkHandler,
						        .receiverTimeout = 1*9
						    };

						uartControl.configureUart(&cfg);
					'''
				}
			}
		}
	}

// This is an example protocol. You can define your own protocol(s).

	ProtocolClass PMyCustomProtocol {
		incoming {
			Message sendData(DCustomUartNotification)
		}

		outgoing {
			Message receivedData(DCustomUartNotification)
			Message uartReady()
		}
	}

	ActorClass AProtocolControlLogicActor {

		Interface {
			conjugated Port uartInterface: PMyCustomProtocol
		}
		Structure {
			Attribute msgBuffer [50]: uint8
			external Port uartInterface
			SAP timer: PTimer
			SAP logger: PLogger
		}

		Behavior {
			StateMachine {
				State waitForUartReady
				State running
				Transition init0: initial -> waitForUartReady {
					action '''
						timer.startTimer(2000);
					'''
				}
				Transition tr0: waitForUartReady -> running {
					triggers {
						<uartReady: uartInterface>
					}
				}
				Transition tr1: running -> running {
					triggers {
						<receivedData: uartInterface>
					}
					action '''
                        // You can add your protocol handling here. The below lines only print
                        // the received data into the logger.

                        // zero terminate received string and forward it to logger
                        *(transitionData->bufferPtr + transitionData->dataLength) = '\0';
                        logger.log((char *)(transitionData->bufferPtr));'''
				}
				Transition tr2: running -> running {
					triggers {
						<timeout: timer>
					}
					action '''
						// get the length of the example string, put the contents in the msgBuffer
						uint16_t length = snprintf((char *)msgBuffer, 255, "Some test data to be sent\n");
						// check if snprintf returned successfully
						if (length > 0 && length < 256) {
							// prepare the data structure to send
						    DCustomUartNotification sendReq = {
						        .bufferPtr = msgBuffer,
						        .dataLength = length
						    };
						    // send the data
						    uartInterface.sendData(&sendReq);
						} else {
						    logger.log("CustomUartTester: Could not snprintf...");
						}
					'''
				}
			}
		}
	}

ActorClass ACustomUartTester {
		Interface {
			conjugated Port uartCtrl: PCustomUartControl
			conjugated Port uartCom: PCustomUartCommunication
		}
		Structure {
			usercode1 '''
				#include "uart/Uart.h"
			'''
			usercode3 '''

				static uint8_t __attribute__((section(".dmaMemSection_D2"))) rxBuffers[2][256];
				static uint8_t __attribute__((section(".dmaMemSection_D2"))) txBuffer[256];

				static int16_t chunkHandler(uint8_t* buffer, uint8_t newDataLength) {
					for (uint8_t i = 0; i < newDataLength; i++) {
						if (buffer[i] == '\n') {
							return i - newDataLength;
						}
					}
					return 20; // read the next 20 bytes
				}
			'''
			external Port uartCom
			external Port uartCtrl
			Attribute toggleMsg: uint8 = "0"

			SAP timer: PTimer
			SAP logger: PLogger
		}
		Behavior {

			StateMachine {
				State configuring
				State active
				Transition init0: initial -> delay {
					action '''timer.startTimeout(500);'''
				}
				Transition tr0: configuring -> active {
					triggers {
						<configurationComplete: uartCtrl>
					}
					action '''
						timer.startTimeout(2000);
						uartCtrl.enableReceiveData();'''
				}
				Transition tr1: active -> active {
					triggers {
						<receivedPacket: uartCom>
					}
					action '''
						// zero terminate received string and forward it to logger
						*(transitionData->bufferPtr + transitionData->dataLength) = '\0';
						logger.log((char *)(transitionData->bufferPtr));
						uartCom.freeRxBuffer(transitionData->bufferPtr);'''
				}
				Transition tr2: active -> active {
					triggers {
						<timeout: timer>
					}
					action '''
						// simulate a pause in the bytestream
						timer.startTimeout(1000);

						uint16_t length;

						// single messages are separated by '#'
						if (toggleMsg == 0) {
							length = snprintf((char *)txBuffer, 256, "Test message1#Test message2#Test message3\nTest message4#Tes");
							toggleMsg = 1;
						}
						else {
							length = snprintf((char *)txBuffer, 256, "t message5#Test message6\n");
							toggleMsg = 0;
						}

						if (length > 0 && length < 256) {
						    DCustomUartNotification sendReq = {
						        .bufferPtr = txBuffer,
						        .dataLength = length
						    };
						    uartCom.sendPacket(&sendReq);
						} else {
						    logger.log("CustomUartTester: Could not snprintf...");
						}
						'''
				}
				State delay
				Transition tr3: delay -> configuring {
					triggers {
						<timeout: timer>
					}
					action '''
						DCustomUartConfiguration cfg = {
						    .uartConfig = {
						        .uartBaudrate = 115200,
						        .uartDatabits = EUartDataBits_DATA_BITS_8,
						        .uartParity = EParity_NONE,
						        .uartStopbits = EStopBits_STOPBITS_1
						    },
						    .rxBufferPtrs = {rxBuffers[0], rxBuffers[1]},
						    .noOfRxBuffers = 2,
						    .rxBufferLength = 256,
						    .initialChunkSize = 15,
						    .nextChunkHandler = chunkHandler,
						    .receiverTimeout = 5*9  // 5 * 9 Bit
						};
						uartCtrl.configureUart(&cfg);'''
				}
			}
		}
	}